﻿#include "Date.h"

A f2()
{
	A aa;
	cout << "***********" << endl;
	return aa;//传值返回会有一个把aa拷贝构造出一个临时对象作为返回值
}

int main()
{
	//传值返回

	f2();
	cout << endl;

	//返回时⼀个表达式中，连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造
	A aa2 = f2();
	cout << endl;




	cout << "#########" << endl;
	return 0;
}




//void f1(A aa)
//{
//	cout << "#########" << endl;
//}


//int main()
//{
//	////传值传参
//	//A aa1;
//	//f1(aa1);
//	//cout << endl;
//
//	////隐式类型转换，连续构造+拷贝构造 ->优化为直接构造
//	//f1(1);
//	////原本的语法流程为首先1构造一个临时对象，
//	////临时对象再拷贝构造给临时对象
//	//
//	////现在优化为省去拷贝构造直接构造
//
//	f1(A(2));
//	//原本：匿名对象构造出对象，让后拷贝构造个临时对象作为形参
//	//现在：匿名对象直接替代临时对象，直接当作形参
//
//
//	cout << "******************" << endl;
//	return 0;
//}


//#include <iostream>
//using namespace std;
////练习1
//class S1
//{
//	char c1;
//	int i;
//	char c2;
//
//};
////练习2
//class S2
//{
//	char c1;
//	char c2;
//	int i;
//};
////练习3
//class S3
//{
//	double d;
//	char c;
//	int i;
//};
////练习4：嵌套问题
//class S4
//{
//	char c1;
//	class S3 s3;
//	double d;
//};
//
//int main()
//{
//	cout << sizeof(S1) << endl;//12
//	cout << sizeof(S2) << endl;//8
//	cout << sizeof(S3) << endl;//16
//	cout << sizeof(S4) << endl;//32
//	return 0;
//}


//int main()
//{
//	cout << sizeof(A) << endl;
//
//	return 0;
//}




//int main()
//{
//	//C++11支持多个成员变量的类类型，可以由内置类型隐式类型转化
//	A aa = { 1, 2 };
//	aa.Print();
//
//	return 0;
//}


//int main()
//{
//	A aa;
//	B bb(aa);
//	bb.Print();
//	return 0;
//}

//int main()
//{
//	A aa1(1);
//	aa1.Print();
//
//
//	//隐式类型转换
//	//2 构造一个A的临时对象，在用这个临时对象拷贝构造aa2
//	// 编译器遇到连续构造+拷贝构造 -> 优化为直接构造
//	A aa2 = 2;
//	aa2.Print();
//
//
//	return 0;
//}



//A& raa = aa2;
//const A& raa2 = 2;
//
//int i = 1;
//double d = i;


//int main()
//{
//	A aa1;//有名对象
//
//
//	A(1);//匿名对象,生命周期仅在该行
//	A(2);
//
//
//	aa1.Funca1();//有名对象函数调用
//	A().Funca1();//匿名对象调用，
//
//
//	return 0;
//}











//int A::_k = 0;
//
//int main()
//{
//	A a;
//	A::B b;
//	cout << sizeof(A) << endl;
//	b.foo(a);
//	return 0;
//}



//设已经有A,B,C,D 4个类的定义，
// 程序中A,B,C,D构造函数调⽤顺序为？（）
// 程序中A,B,C,D析构函数调⽤顺序为？（）
//A：D B A C
//B：B A D C
//C：C D B A
//D：A B D C
//E：C A B D
//F：C D A B


//C c;
//在全局定义的对象，空间存在静态区，且在main函数建立栈帧前就已经开好空间
//因此构造是早于生命周期在main函数里的其他变量

//int main()
//{
//	//对于在函数局部域里的变量，构造顺序按照声明顺序
//	A a;
//	B b;
//	static D d;//局部域的静态变量是按照声明的顺序初始化的，静态变量的空间存在内存的静态区
//
//	return 0;
//}
//构造顺序：
//构造函数会在类对象生命周期开始时自动调用，并且构造顺序按照声明的顺序
//因此构造调用的顺序：一看生命周期、二看声明顺序，因此答案为：c a b d


//析构顺序：
//析构是在类对象生命周期结束自动调用的，并且析构的顺序是按 后声明的先析构
//因此看析构的调用顺序是：一看生命周期、二看声明顺序。因此答案为：b a d c





//int A::_scount = 0;//初始化
//
//void Func()
//{
//	A a4;
//	cout << A::getACount() << endl;
//}
//
//int main()
//{
//	//cout << A::getACount() << endl;
//	//cout << sizeof(A) << endl;
//
//	A a1;
//	A a2;
//	A a3(a1);
//	cout << A::getACount() << endl;
//	Func();
//	cout << A::getACount() << endl;
//
//	return 0;
//}



//5.初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关。建议声明顺序和初始化列表顺序保持⼀致。
//int main()
//{
//	A a(1);
//	a.Print();
//	return 0;
//}



//int main()
//{
//	Date d1(2025, 4);
//	//Date d1;//编译器自动生成默认构造函数
//
//	d1.Print();
//	return 0;
//}



//test_**引用成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进行初始化**，否则会编译报错。
//int main()
//{
//	int x = 0;
//
//	Date d1(x);
//	d1.Print();
//	return 0;
//}